package org.assistant.common.web.servlet.mvc;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import net.sf.json.JSONObject;
import net.sf.json.JsonConfig;
import net.sf.json.processors.JsonValueProcessor;

/**
 * 分页信息类
 * 
 * @author zhangQiong
 * 
 */
class Pagination {
	private int totalCount;// 总记录数（用于分页），从0开始
	private int currentPage;// 当前页（用于分页），从1开始
	private int pageSize;// 每页大小（用于分页），从0开始

	/**
	 * 获取data中的总记录数
	 * 
	 * @return
	 */
	public int getTotalCount() {
		return totalCount;
	}

	/**
	 * 设置data中的总记录数
	 * 
	 * @param totalCount
	 */
	public void setTotalCount(int totalCount) {
		this.totalCount = totalCount;
	}

	/**
	 * 获取当前页号，从1开始
	 * 
	 * @return
	 */
	public int getCurrentPage() {
		return currentPage;
	}

	/**
	 * 设置当前页号，从1开始
	 * 
	 * @param currentPage
	 */
	public void setCurrentPage(int currentPage) {
		this.currentPage = currentPage;
	}

	/**
	 * 获取总页数
	 * 
	 * @return
	 */
	public int getAllPage() {
		return (totalCount - 1) / pageSize + 1;
	}

	/**
	 * 获取每页大小，从0开始
	 * 
	 * @return
	 */
	public int getPageSize() {
		return pageSize;
	}

	/**
	 * 设置每页大小，从0开始
	 * 
	 * @param pageSize
	 */
	public void setPageSize(int pageSize) {
		this.pageSize = pageSize;
	}
}

/**
 * 结果类，用于后台向前台返回数据
 * 
 * @author zhangQiong
 * 
 * @param <T>
 */
public class ResultData<T> {
	private boolean success = true;// 用于标记是否成功
	private DataType type;// 存放在ResultData中的需要返回到前台的数据类型
	private T data;// 需要返回到前台的数据
	private Pagination pagination;// 分页信息，如果查询结果不需要分页，则其值为null.
	private String message;// 需要返回到前台的消息
	private String exception;// 需要返回到前台的异常信息
	private Map<String, Object> userDataMap;// 用户自定义数据

	/**
	 * 默认构造函数
	 */
	public ResultData() {
	}

	/**
	 * 构造函数
	 * 
	 * @param data
	 *            ，要放到ResultData中的数据
	 */
	public ResultData(T data) {
		if (data instanceof Map<?, ?>) {
			this.type = DataType.map;
		} else if (data instanceof List<?>) {
			this.type = DataType.list;
		} else if (data instanceof String) {
			this.type = DataType.json_string;
		} else {
			this.type = DataType.object;
		}
		this.data = data;
	}

	/**
	 * 构造函数，此构造函数通常用于存储original_json、original_xml类型的数据
	 * 
	 * @param data
	 *            ，要放到ResultData中的数据
	 * @param dataType
	 *            ，要放到ResultData中的数据的类型
	 */
	public ResultData(T data, DataType dataType) {
		this.data = data;
		this.type = dataType;
	}

	/**
	 * 获取JSON字符串（将ResultData中的data、message、exception转化为JSON字符串）
	 * 
	 * @return
	 */
	public String getJSONString() {
		// json解析处理器
		JsonValueProcessor jsonValueProcessor = new JsonValueProcessor() {
			SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

			public Object processArrayValue(Object value, JsonConfig jsonConfig) {
				String[] obj = {};
				if (value instanceof Date[]) {
					Date[] dates = (Date[]) value;
					obj = new String[dates.length];
					for (int i = 0; i < dates.length; i++) {
						obj[i] = sdf.format(dates[i]);
					}
				}
				return obj;
			}

			public Object processObjectValue(String key, Object value,
					JsonConfig jsonConfig) {
				if (value instanceof Date) {
					String str = sdf.format((Date) value);
					return str;
				}
				return value.toString();
			}
		};
		// 注册json值解析处理器
		JsonConfig jsonConfig = new JsonConfig();
		jsonConfig.registerJsonValueProcessor(
			java.util.Date.class, jsonValueProcessor);
		jsonConfig.registerJsonValueProcessor(
			java.sql.Date.class, jsonValueProcessor);

		// 生成JSON字符串
		StringBuffer buffer = new StringBuffer();
		buffer.append("{");
		buffer.append("'success':'").append(isSuccess()).append("',");
		buffer.append("'data':");
		if (null != getData()) {
			if (getType() == DataType.json_string) {
				buffer.append(getData());
			} else if (getType() == DataType.map) {
				JSONObject jsonObject = JSONObject.fromObject(
					this.data, jsonConfig);
				buffer.append(jsonObject.toString());
			} else if (getType() == DataType.object) {
				JSONObject jsonObject = JSONObject.fromObject(
					this.data, jsonConfig);
				buffer.append(jsonObject.toString());
			} else if (getType() == DataType.list) {
				JSONObject jsonObject = JSONObject.fromObject(
					this.data, jsonConfig);
				buffer.append(jsonObject.toString());
			}
		} else {
			buffer.append("{}");
		}
		buffer.append("");
		if (null != getMessage()) {
			buffer.append(",'message':'").append(getMessage()).append("'");
		}
		if (null != getException()) {
			buffer.append(",'exception':'").append(getException()).append("'");
		}
		if (null != getUserDataMap()) {
			buffer.append(",'userData':");
			buffer.append("{");
			Map<String, Object> map = getUserDataMap();
			Iterator<Entry<String, Object>> mapIt = map.entrySet().iterator();
			boolean hasNext = false;
			while (mapIt.hasNext()) {
				Entry<String, Object> entry = mapIt.next();
				String key = entry.getKey();
				Object value = entry.getValue();
				buffer.append("'").append(key).append("':");
				buffer.append("'").append(value).append("'");
				buffer.append(",");
				hasNext = true;
			}
			if (hasNext) {
				buffer.deleteCharAt(buffer.length() - 1);// 删除最后一个逗号
			}
			buffer.append("}");
		}
		buffer.append("}");

		return buffer.toString();
	}

	/**
	 * 获取Data中的数据类型
	 * 
	 * @return
	 */
	public DataType getType() {
		return type;
	}

	/**
	 * 设置Data中的数据类型
	 * 
	 * @param type
	 */
	public void setType(DataType type) {
		this.type = type;
	}

	/**
	 * 获取存放在ResultData中的需要返回到前台的数据
	 * 
	 * @return
	 */
	public T getData() {
		return this.data;
	}

	/**
	 * 设置需要返回到前台的数据到ResultData中
	 * 
	 * @param data
	 */
	public void setData(T data) {
		if (data instanceof Map<?, ?>) {
			this.type = DataType.map;
		} else if (data instanceof List<?>) {
			this.type = DataType.list;
		} else if (data instanceof String) {
			this.type = DataType.json_string;
		} else {
			this.type = DataType.object;
		}
		this.data = data;
	}

	/**
	 * 获取需要返回到前台的消息
	 * 
	 * @return
	 */
	public String getMessage() {
		return message;
	}

	/**
	 * 设置需要返回到前台的消息
	 * 
	 * @param message
	 */
	public void setMessage(String message) {
		this.message = message;
	}

	/**
	 * 获取需要返回到前台的异常信息
	 * 
	 * @return
	 */
	public String getException() {
		return exception;
	}

	/**
	 * 设置需要返回到前台的异常信息
	 * 
	 * @param exception
	 */
	public void setException(String exception) {
		this.success = false;
		this.exception = exception;
	}

	/**
	 * 获取分页信息，如果查询结果不需要分页，则其值为null.
	 * 
	 * @return
	 */
	public Pagination getPagination() {
		return pagination;
	}

	/**
	 * 设置分页信息，如果查询结果不需要分页，则其值为null.
	 * 
	 * @param pagingBean
	 */
	public void setPagination(Pagination pagination) {
		this.pagination = pagination;
	}

	public boolean isSuccess() {
		return success;
	}

	public void setSuccess(boolean success) {
		this.success = success;
	}

	/**
	 * put一条用户自定义数据，目前仅支持String类型的数据
	 * 
	 * @param key
	 * @param data
	 */
	public void putUserData(String key, Object data) {
		if (key == null) {
			throw new IllegalArgumentException(
				"UserData's Key must not be null");
		}
		if (userDataMap == null) {
			userDataMap = new HashMap<String, Object>();
		}
		userDataMap.put(key, data);
	}

	public Map<String, Object> getUserDataMap() {
		return userDataMap;
	}
}
